﻿#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stdlib.h>

using namespace std;

//int a = 1;
//static int b = 1;
//
//void test()
//{
//	static int c = 1;
//	int d = 1;
//	int nums1[10] = { 1, 2, 3, 4 };
//	char char2[] = "abcd";
//	const char* pChar3 = "abcd";
//	int* ptr1 = (int*)malloc(sizeof(int) * 4);
//	int* ptr2 = (int*)calloc(4, sizeof(int));
//	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
//	free(ptr1);
//	free(ptr3);
//}

//void test()
//{
//	//动态申请一个int类型的空间
//	int* ptr1 = new int;
//
//	//动态申请一个int类型的空间并初始化为10
//	int* ptr2 = new int(10);
//
//	//动态申请三个int空间
//	int* ptr3 = new int[3];
//
//	//动态申请三个int空间并初始化为{1, 2, 3}
//	int* ptr3 = new int[3] {1, 2, 3};
//
//	delete ptr1;
//	delete ptr2;
//	delete[] ptr3;
//}

//class A
//{
//public:
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A():" << this << endl;
//	}
//	~A()
//	{
//		cout << "~A():" << this << endl;
//	}
//private:
//	int _a;
//};
//
//int main()
//{
//	/*A* p1 = (A*)malloc(sizeof(A));
//	A* p2 = new A(1);
//	free(p1);
//	delete p2;*/
//
//	// 内置类型是几乎是一样的
//	int* p3 = (int*)malloc(sizeof(int));
//	int* p4 = new int;
//	free(p3);
//	delete p4;
//
//	//开辟连续空间
//	A* p5 = (A*)malloc(sizeof(A) * 10);
//	A* p6 = new A[10];
//	free(p5);
//	delete[] p6;
//
//	return 0;
//}

//int main()
//{
//	int* ptr1 = (int*)operator new(sizeof(int));
//	int* ptr2 = new int;
//	operator delete(ptr1);
//	delete ptr2;
//	return 0;
//}

//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (int*)malloc(sizeof(int) * n);
//		if (_a == nullptr)
//		{
//			perror("malloc fail!");
//			exit(1);
//		}
//		_top = 0;
//		_capacity = n;
//	}
//	~Stack()
//	{
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//private:
//	int* _a;
//	int _top;
//	int _capacity;
//};
//
//
//int main()
//{
//	Stack* st = new Stack;
//	delete st;
//	return 0;
//}


//class A
//{
//public:
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A():" << endl;
//	}
//	~A()
//	{
//		cout << "~A():" << endl;
//	}
//private:
//	int _a;
//};
//
//// 定位new/replacement new
//int main()
//{
//	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行,并没有进行初始化
//	A* p1 = (A*)malloc(sizeof(A));
//	new(p1)A;     // 调用A类的构造函数初始化空间为对象
//	p1->~A();
//	free(p1);
//	A* p2 = (A*)operator new(sizeof(A));
//	new(p2)A(10);
//	p2->~A();
//	operator delete(p2);
//	return 0;
//}


//template<typename T>
//void Swap(T& left, T& right)
//{
//	T temp = left;
//	left = right;
//	right = temp;
//}
//
//
//int main()
//{
//	int a1 = 1, a2 = 5;
//	double b1 = 3.3, b2 = 5.0;
//	char c1 = 'h', c2 = 'e';
//	Swap(a1, a2);
//	Swap(b1, b2);
//	Swap(c1, c2);
//
//	cout << a1 << " " << a2 << endl;
//	cout << b1 << " " << b2 << endl;
//	cout << c1 << " " << c2 << endl;
//	return 0;
//}

//template<class T>
//T Add(const T& left, const T& right)
//{
//	return left + right;
//}
//
//int main()
//{
//	int a1 = 10, a2 = 20;
//	double d1 = 10.0, d2 = 20.0;
//	Add(a1, a2);
//	Add(d1, d2);
// 
////	    该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
////	    通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有
////   一个T，
////	    编译器无法确定此处到底该将T确定为int 或者 double类型而报错
////		 注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要
////背黑锅
////     Add(a1, d1);
//	// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
//	Add(a1, (int)d1);
//	return 0;
//}



class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << endl;
	}
	/*~A()
	{
		cout << "~A():" << endl;
	}*/
private:
	int _a;
};


int main()
{
	A* p1 = new A[10];
	delete p1;
	return 0;
}

